#!/usr/bin/env python3
"""
perl-Pod-Markdown MCP Server

面向软件：perl-Pod-Markdown (pod2markdown 工具)
pod2markdown 是一个将 Perl POD 文档转换为 Markdown 格式的命令行工具。

MCP tools 列表：
1. pod2markdown_help - 显示 pod2markdown 帮助信息
   参数：无
   返回：命令执行结果

2. pod2markdown_stdio - 标准输入输出模式转换 POD 为 Markdown
   参数：input_file (str) - 输入 POD 文件路径
   返回：命令执行结果

3. pod2markdown_fileio - 文件输入输出模式转换 POD 为 Markdown
   参数：input_file (str) - 输入 POD 文件路径, output_file (str) - 输出 Markdown 文件路径
   返回：命令执行结果

4. pod2markdown_stdin_fileout - 标准输入文件输出模式转换
   参数：input_file (str) - 输入 POD 文件路径, output_file (str) - 输出 Markdown 文件路径
   返回：命令执行结果

5. pod2markdown_utf8 - 使用 UTF-8 编码转换 POD
   参数：input_file (str) - 输入 POD 文件路径, use_short_option (bool) - 是否使用短选项 (-u)
   返回：命令执行结果

6. pod2markdown_output_encoding - 设置输出编码
   参数：input_file (str) - 输入 POD 文件路径, encoding (str) - 输出编码, use_short_option (bool) - 是否使用短选项 (-e)
   返回：命令执行结果

7. pod2markdown_match_encoding - 设置匹配编码
   参数：input_file (str) - 输入 POD 文件路径, use_short_option (bool) - 是否使用短选项 (-m)
   返回：命令执行结果

8. pod2markdown_html_encode_chars - HTML 字符编码设置
   参数：input_file (str) - 输入 POD 文件路径, chars (str) - 要编码的字符
   返回：命令执行结果

所有工具返回统一 JSON 结构：
{
  "success": bool,      # 命令是否成功执行
  "command": str,       # 实际执行的命令
  "exit_code": int,     # 命令退出码
  "stdout": str,        # 标准输出内容
  "stderr": str         # 标准错误内容
}
"""

import subprocess
import shlex
from typing import List
from mcp.server.fastmcp import FastMCP, Context

mcp = FastMCP("Perl-Pod-Markdown MCP Server")

@mcp.tool()
def pod2markdown_help() -> dict:
    """显示 pod2markdown 命令的帮助信息
    
    返回:
        dict: 包含命令执行结果的字典
    """
    command = "pod2markdown -h"
    try:
        result = subprocess.run(
            shlex.split(command),
            capture_output=True,
            text=True,
            timeout=30
        )
        return {
            "success": result.returncode == 0,
            "command": command,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def pod2markdown_stdio(input_file: str) -> dict:
    """标准输入输出模式：从文件读取 POD 并输出 Markdown 到标准输出
    
    参数:
        input_file (str): 输入的 POD 文件路径
        
    返回:
        dict: 包含命令执行结果的字典
    """
    command = f"pod2markdown {shlex.quote(input_file)}"
    try:
        result = subprocess.run(
            shlex.split(command),
            capture_output=True,
            text=True,
            timeout=30
        )
        return {
            "success": result.returncode == 0,
            "command": command,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def pod2markdown_fileio(input_file: str, output_file: str) -> dict:
    """文件输入输出模式：从文件读取 POD 并输出 Markdown 到指定文件
    
    参数:
        input_file (str): 输入的 POD 文件路径
        output_file (str): 输出的 Markdown 文件路径
        
    返回:
        dict: 包含命令执行结果的字典
    """
    command = f"pod2markdown {shlex.quote(input_file)} {shlex.quote(output_file)}"
    try:
        result = subprocess.run(
            shlex.split(command),
            capture_output=True,
            text=True,
            timeout=30
        )
        return {
            "success": result.returncode == 0,
            "command": command,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def pod2markdown_stdin_fileout(input_file: str, output_file: str) -> dict:
    """标准输入文件输出模式：从标准输入读取 POD 并输出 Markdown 到文件
    
    参数:
        input_file (str): 输入的 POD 文件路径（通过重定向提供）
        output_file (str): 输出的 Markdown 文件路径
        
    返回:
        dict: 包含命令执行结果的字典
    """
    command = f"pod2markdown - {shlex.quote(output_file)}"
    try:
        with open(input_file, 'r') as f:
            result = subprocess.run(
                shlex.split(command),
                stdin=f,
                capture_output=True,
                text=True,
                timeout=30
            )
        return {
            "success": result.returncode == 0,
            "command": command,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def pod2markdown_utf8(input_file: str, use_short_option: bool = True) -> dict:
    """使用 UTF-8 编码转换 POD 文档
    
    参数:
        input_file (str): 输入的 POD 文件路径
        use_short_option (bool): 是否使用短选项 (-u)，否则使用长选项 (--utf8)
        
    返回:
        dict: 包含命令执行结果的字典
    """
    option = "-u" if use_short_option else "--utf8"
    command = f"pod2markdown {option} {shlex.quote(input_file)}"
    try:
        result = subprocess.run(
            shlex.split(command),
            capture_output=True,
            text=True,
            timeout=30
        )
        return {
            "success": result.returncode == 0,
            "command": command,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def pod2markdown_output_encoding(input_file: str, encoding: str, use_short_option: bool = True) -> dict:
    """设置输出编码格式
    
    参数:
        input_file (str): 输入的 POD 文件路径
        encoding (str): 输出编码格式（如 ascii, utf8 等）
        use_short_option (bool): 是否使用短选项 (-e)，否则使用长选项 (--output-encoding)
        
    返回:
        dict: 包含命令执行结果的字典
    """
    option = "-e" if use_short_option else "--output-encoding"
    command = f"pod2markdown {option} {shlex.quote(encoding)} {shlex.quote(input_file)}"
    try:
        result = subprocess.run(
            shlex.split(command),
            capture_output=True,
            text=True,
            timeout=30
        )
        return {
            "success": result.returncode == 0,
            "command": command,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def pod2markdown_match_encoding(input_file: str, use_short_option: bool = True) -> dict:
    """设置匹配编码选项
    
    参数:
        input_file (str): 输入的 POD 文件路径
        use_short_option (bool): 是否使用短选项 (-m)，否则使用长选项 (--match-encoding)
        
    返回:
        dict: 包含命令执行结果的字典
    """
    option = "-m" if use_short_option else "--match-encoding"
    command = f"pod2markdown {option} {shlex.quote(input_file)}"
    try:
        result = subprocess.run(
            shlex.split(command),
            capture_output=True,
            text=True,
            timeout=30
        )
        return {
            "success": result.returncode == 0,
            "command": command,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

@mcp.tool()
def pod2markdown_html_encode_chars(input_file: str, chars: str) -> dict:
    """设置 HTML 字符编码
    
    参数:
        input_file (str): 输入的 POD 文件路径
        chars (str): 要编码的字符（如 '1', '!' 等）
        
    返回:
        dict: 包含命令执行结果的字典
    """
    command = f"pod2markdown --html-encode-chars {shlex.quote(chars)} {shlex.quote(input_file)}"
    try:
        result = subprocess.run(
            shlex.split(command),
            capture_output=True,
            text=True,
            timeout=30
        )
        return {
            "success": result.returncode == 0,
            "command": command,
            "exit_code": result.returncode,
            "stdout": result.stdout,
            "stderr": result.stderr
        }
    except Exception as e:
        return {
            "success": False,
            "command": command,
            "exit_code": -1,
            "stdout": "",
            "stderr": str(e)
        }

if __name__ == "__main__":
    mcp.run()